1   /*
2    * Copyright (C) 2008 The Guava Authors
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    * http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package com.google.common.primitives;
18  
19  import com.google.common.annotations.GwtCompatible;
20  import com.google.common.annotations.GwtIncompatible;
21  import com.google.common.base.Converter;
22  import com.google.common.collect.testing.Helpers;
23  import com.google.common.testing.NullPointerTester;
24  import com.google.common.testing.SerializableTester;
25  
26  import junit.framework.TestCase;
27  
28  import java.util.Arrays;
29  import java.util.Collection;
30  import java.util.Collections;
31  import java.util.Comparator;
32  import java.util.List;
33  import java.util.Random;
34  
35  /**
36   * Unit test for {@link Ints}.
37   *
38   * @author Kevin Bourrillion
39   */
40  @GwtCompatible(emulated = true)
41  @SuppressWarnings("cast") // redundant casts are intentional and harmless
42  public class IntsTest extends TestCase {
43    private static final int[] EMPTY = {};
44    private static final int[] ARRAY1 = {(int) 1};
45    private static final int[] ARRAY234
46        = {(int) 2, (int) 3, (int) 4};
47  
48    private static final int LEAST = Integer.MIN_VALUE;
49    private static final int GREATEST = Integer.MAX_VALUE;
50  
51    private static final int[] VALUES =
52        { LEAST, (int) -1, (int) 0, (int) 1, GREATEST };
53  
54    public void testHashCode() {
55      for (int value : VALUES) {
56        assertEquals(((Integer) value).hashCode(), Ints.hashCode(value));
57      }
58    }
59  
60    public void testCheckedCast() {
61      for (int value : VALUES) {
62        assertEquals(value, Ints.checkedCast((long) value));
63      }
64      assertCastFails(GREATEST + 1L);
65      assertCastFails(LEAST - 1L);
66      assertCastFails(Long.MAX_VALUE);
67      assertCastFails(Long.MIN_VALUE);
68    }
69  
70    public void testSaturatedCast() {
71      for (int value : VALUES) {
72        assertEquals(value, Ints.saturatedCast((long) value));
73      }
74      assertEquals(GREATEST, Ints.saturatedCast(GREATEST + 1L));
75      assertEquals(LEAST, Ints.saturatedCast(LEAST - 1L));
76      assertEquals(GREATEST, Ints.saturatedCast(Long.MAX_VALUE));
77      assertEquals(LEAST, Ints.saturatedCast(Long.MIN_VALUE));
78    }
79  
80    private static void assertCastFails(long value) {
81      try {
82        Ints.checkedCast(value);
83        fail("Cast to int should have failed: " + value);
84      } catch (IllegalArgumentException ex) {
85        assertTrue(value + " not found in exception text: " + ex.getMessage(),
86            ex.getMessage().contains(String.valueOf(value)));
87      }
88    }
89  
90    public void testCompare() {
91      for (int x : VALUES) {
92        for (int y : VALUES) {
93          // note: spec requires only that the sign is the same
94          assertEquals(x + ", " + y,
95                       Integer.valueOf(x).compareTo(y),
96                       Ints.compare(x, y));
97        }
98      }
99    }
100 
101   public void testContains() {
102     assertFalse(Ints.contains(EMPTY, (int) 1));
103     assertFalse(Ints.contains(ARRAY1, (int) 2));
104     assertFalse(Ints.contains(ARRAY234, (int) 1));
105     assertTrue(Ints.contains(new int[] {(int) -1}, (int) -1));
106     assertTrue(Ints.contains(ARRAY234, (int) 2));
107     assertTrue(Ints.contains(ARRAY234, (int) 3));
108     assertTrue(Ints.contains(ARRAY234, (int) 4));
109   }
110 
111   public void testIndexOf() {
112     assertEquals(-1, Ints.indexOf(EMPTY, (int) 1));
113     assertEquals(-1, Ints.indexOf(ARRAY1, (int) 2));
114     assertEquals(-1, Ints.indexOf(ARRAY234, (int) 1));
115     assertEquals(0, Ints.indexOf(
116         new int[] {(int) -1}, (int) -1));
117     assertEquals(0, Ints.indexOf(ARRAY234, (int) 2));
118     assertEquals(1, Ints.indexOf(ARRAY234, (int) 3));
119     assertEquals(2, Ints.indexOf(ARRAY234, (int) 4));
120     assertEquals(1, Ints.indexOf(
121         new int[] { (int) 2, (int) 3, (int) 2, (int) 3 },
122         (int) 3));
123   }
124 
125   public void testIndexOf_arrayTarget() {
126     assertEquals(0, Ints.indexOf(EMPTY, EMPTY));
127     assertEquals(0, Ints.indexOf(ARRAY234, EMPTY));
128     assertEquals(-1, Ints.indexOf(EMPTY, ARRAY234));
129     assertEquals(-1, Ints.indexOf(ARRAY234, ARRAY1));
130     assertEquals(-1, Ints.indexOf(ARRAY1, ARRAY234));
131     assertEquals(0, Ints.indexOf(ARRAY1, ARRAY1));
132     assertEquals(0, Ints.indexOf(ARRAY234, ARRAY234));
133     assertEquals(0, Ints.indexOf(
134         ARRAY234, new int[] { (int) 2, (int) 3 }));
135     assertEquals(1, Ints.indexOf(
136         ARRAY234, new int[] { (int) 3, (int) 4 }));
137     assertEquals(1, Ints.indexOf(ARRAY234, new int[] { (int) 3 }));
138     assertEquals(2, Ints.indexOf(ARRAY234, new int[] { (int) 4 }));
139     assertEquals(1, Ints.indexOf(new int[] { (int) 2, (int) 3,
140         (int) 3, (int) 3, (int) 3 },
141         new int[] { (int) 3 }
142     ));
143     assertEquals(2, Ints.indexOf(
144         new int[] { (int) 2, (int) 3, (int) 2,
145             (int) 3, (int) 4, (int) 2, (int) 3},
146         new int[] { (int) 2, (int) 3, (int) 4}
147     ));
148     assertEquals(1, Ints.indexOf(
149         new int[] { (int) 2, (int) 2, (int) 3,
150             (int) 4, (int) 2, (int) 3, (int) 4},
151         new int[] { (int) 2, (int) 3, (int) 4}
152     ));
153     assertEquals(-1, Ints.indexOf(
154         new int[] { (int) 4, (int) 3, (int) 2},
155         new int[] { (int) 2, (int) 3, (int) 4}
156     ));
157   }
158 
159   public void testLastIndexOf() {
160     assertEquals(-1, Ints.lastIndexOf(EMPTY, (int) 1));
161     assertEquals(-1, Ints.lastIndexOf(ARRAY1, (int) 2));
162     assertEquals(-1, Ints.lastIndexOf(ARRAY234, (int) 1));
163     assertEquals(0, Ints.lastIndexOf(
164         new int[] {(int) -1}, (int) -1));
165     assertEquals(0, Ints.lastIndexOf(ARRAY234, (int) 2));
166     assertEquals(1, Ints.lastIndexOf(ARRAY234, (int) 3));
167     assertEquals(2, Ints.lastIndexOf(ARRAY234, (int) 4));
168     assertEquals(3, Ints.lastIndexOf(
169         new int[] { (int) 2, (int) 3, (int) 2, (int) 3 },
170         (int) 3));
171   }
172 
173   public void testMax_noArgs() {
174     try {
175       Ints.max();
176       fail();
177     } catch (IllegalArgumentException expected) {
178     }
179   }
180 
181   public void testMax() {
182     assertEquals(LEAST, Ints.max(LEAST));
183     assertEquals(GREATEST, Ints.max(GREATEST));
184     assertEquals((int) 9, Ints.max(
185         (int) 8, (int) 6, (int) 7,
186         (int) 5, (int) 3, (int) 0, (int) 9));
187   }
188 
189   public void testMin_noArgs() {
190     try {
191       Ints.min();
192       fail();
193     } catch (IllegalArgumentException expected) {
194     }
195   }
196 
197   public void testMin() {
198     assertEquals(LEAST, Ints.min(LEAST));
199     assertEquals(GREATEST, Ints.min(GREATEST));
200     assertEquals((int) 0, Ints.min(
201         (int) 8, (int) 6, (int) 7,
202         (int) 5, (int) 3, (int) 0, (int) 9));
203   }
204 
205   public void testConcat() {
206     assertTrue(Arrays.equals(EMPTY, Ints.concat()));
207     assertTrue(Arrays.equals(EMPTY, Ints.concat(EMPTY)));
208     assertTrue(Arrays.equals(EMPTY, Ints.concat(EMPTY, EMPTY, EMPTY)));
209     assertTrue(Arrays.equals(ARRAY1, Ints.concat(ARRAY1)));
210     assertNotSame(ARRAY1, Ints.concat(ARRAY1));
211     assertTrue(Arrays.equals(ARRAY1, Ints.concat(EMPTY, ARRAY1, EMPTY)));
212     assertTrue(Arrays.equals(
213         new int[] {(int) 1, (int) 1, (int) 1},
214         Ints.concat(ARRAY1, ARRAY1, ARRAY1)));
215     assertTrue(Arrays.equals(
216         new int[] {(int) 1, (int) 2, (int) 3, (int) 4},
217         Ints.concat(ARRAY1, ARRAY234)));
218   }
219 
220   @GwtIncompatible("Ints.toByteArray")
221   public void testToByteArray() {
222     assertTrue(Arrays.equals(
223         new byte[] {0x12, 0x13, 0x14, 0x15}, Ints.toByteArray(0x12131415)));
224     assertTrue(Arrays.equals(
225         new byte[] {(byte) 0xFF, (byte) 0xEE, (byte) 0xDD, (byte) 0xCC},
226         Ints.toByteArray(0xFFEEDDCC)));
227   }
228 
229   @GwtIncompatible("Ints.fromByteArray")
230   public void testFromByteArray() {
231     assertEquals(0x12131415,
232         Ints.fromByteArray(new byte[] {0x12, 0x13, 0x14, 0x15, 0x33}));
233     assertEquals(0xFFEEDDCC, Ints.fromByteArray(
234         new byte[] {(byte) 0xFF, (byte) 0xEE, (byte) 0xDD, (byte) 0xCC}));
235 
236     try {
237       Ints.fromByteArray(new byte[Ints.BYTES - 1]);
238       fail();
239     } catch (IllegalArgumentException expected) {
240     }
241   }
242 
243   @GwtIncompatible("Ints.fromBytes")
244   public void testFromBytes() {
245     assertEquals(0x12131415, Ints.fromBytes(
246         (byte) 0x12, (byte) 0x13, (byte) 0x14, (byte) 0x15));
247     assertEquals(0xFFEEDDCC, Ints.fromBytes(
248         (byte) 0xFF, (byte) 0xEE, (byte) 0xDD, (byte) 0xCC));
249   }
250 
251   @GwtIncompatible("Ints.fromByteArray, Ints.toByteArray")
252   public void testByteArrayRoundTrips() {
253     Random r = new Random(5);
254     byte[] b = new byte[Ints.BYTES];
255 
256     // total overkill, but, it takes 0.1 sec so why not...
257     for (int i = 0; i < 10000; i++) {
258       int num = r.nextInt();
259       assertEquals(num, Ints.fromByteArray(Ints.toByteArray(num)));
260 
261       r.nextBytes(b);
262       assertTrue(Arrays.equals(b, Ints.toByteArray(Ints.fromByteArray(b))));
263     }
264   }
265 
266   public void testEnsureCapacity() {
267     assertSame(EMPTY, Ints.ensureCapacity(EMPTY, 0, 1));
268     assertSame(ARRAY1, Ints.ensureCapacity(ARRAY1, 0, 1));
269     assertSame(ARRAY1, Ints.ensureCapacity(ARRAY1, 1, 1));
270     assertTrue(Arrays.equals(
271         new int[] {(int) 1, (int) 0, (int) 0},
272         Ints.ensureCapacity(ARRAY1, 2, 1)));
273   }
274 
275   public void testEnsureCapacity_fail() {
276     try {
277       Ints.ensureCapacity(ARRAY1, -1, 1);
278       fail();
279     } catch (IllegalArgumentException expected) {
280     }
281     try {
282       // notice that this should even fail when no growth was needed
283       Ints.ensureCapacity(ARRAY1, 1, -1);
284       fail();
285     } catch (IllegalArgumentException expected) {
286     }
287   }
288 
289   public void testJoin() {
290     assertEquals("", Ints.join(",", EMPTY));
291     assertEquals("1", Ints.join(",", ARRAY1));
292     assertEquals("1,2", Ints.join(",", (int) 1, (int) 2));
293     assertEquals("123",
294         Ints.join("", (int) 1, (int) 2, (int) 3));
295   }
296 
297   public void testLexicographicalComparator() {
298     List<int[]> ordered = Arrays.asList(
299         new int[] {},
300         new int[] {LEAST},
301         new int[] {LEAST, LEAST},
302         new int[] {LEAST, (int) 1},
303         new int[] {(int) 1},
304         new int[] {(int) 1, LEAST},
305         new int[] {GREATEST, GREATEST - (int) 1},
306         new int[] {GREATEST, GREATEST},
307         new int[] {GREATEST, GREATEST, GREATEST});
308 
309     Comparator<int[]> comparator = Ints.lexicographicalComparator();
310     Helpers.testComparator(comparator, ordered);
311   }
312 
313   @GwtIncompatible("SerializableTester")
314   public void testLexicographicalComparatorSerializable() {
315     Comparator<int[]> comparator = Ints.lexicographicalComparator();
316     assertSame(comparator, SerializableTester.reserialize(comparator));
317   }
318 
319   @GwtIncompatible("SerializableTester")
320   public void testStringConverterSerialization() {
321     SerializableTester.reserializeAndAssert(Ints.stringConverter());
322   }
323 
324   public void testToArray() {
325     // need explicit type parameter to avoid javac warning!?
326     List<Integer> none = Arrays.<Integer>asList();
327     assertTrue(Arrays.equals(EMPTY, Ints.toArray(none)));
328 
329     List<Integer> one = Arrays.asList((int) 1);
330     assertTrue(Arrays.equals(ARRAY1, Ints.toArray(one)));
331 
332     int[] array = {(int) 0, (int) 1, (int) 0xdeadbeef};
333 
334     List<Integer> three = Arrays.asList((int) 0, (int) 1, (int) 0xdeadbeef);
335     assertTrue(Arrays.equals(array, Ints.toArray(three)));
336 
337     assertTrue(Arrays.equals(array, Ints.toArray(Ints.asList(array))));
338   }
339 
340   public void testToArray_threadSafe() {
341     for (int delta : new int[] { +1, 0, -1 }) {
342       for (int i = 0; i < VALUES.length; i++) {
343         List<Integer> list = Ints.asList(VALUES).subList(0, i);
344         Collection<Integer> misleadingSize =
345             Helpers.misleadingSizeCollection(delta);
346         misleadingSize.addAll(list);
347         int[] arr = Ints.toArray(misleadingSize);
348         assertEquals(i, arr.length);
349         for (int j = 0; j < i; j++) {
350           assertEquals(VALUES[j], arr[j]);
351         }
352       }
353     }
354   }
355 
356   public void testToArray_withNull() {
357     List<Integer> list = Arrays.asList((int) 0, (int) 1, null);
358     try {
359       Ints.toArray(list);
360       fail();
361     } catch (NullPointerException expected) {
362     }
363   }
364 
365   public void testToArray_withConversion() {
366     int[] array = {0, 1, 2};
367 
368     List<Byte> bytes = Arrays.asList((byte) 0, (byte) 1, (byte) 2);
369     List<Short> shorts = Arrays.asList((short) 0, (short) 1, (short) 2);
370     List<Integer> ints = Arrays.asList(0, 1, 2);
371     List<Float> floats = Arrays.asList((float) 0, (float) 1, (float) 2);
372     List<Long> longs = Arrays.asList((long) 0, (long) 1, (long) 2);
373     List<Double> doubles = Arrays.asList((double) 0, (double) 1, (double) 2);
374 
375     assertTrue(Arrays.equals(array, Ints.toArray(bytes)));
376     assertTrue(Arrays.equals(array, Ints.toArray(shorts)));
377     assertTrue(Arrays.equals(array, Ints.toArray(ints)));
378     assertTrue(Arrays.equals(array, Ints.toArray(floats)));
379     assertTrue(Arrays.equals(array, Ints.toArray(longs)));
380     assertTrue(Arrays.equals(array, Ints.toArray(doubles)));
381   }
382 
383   public void testAsList_isAView() {
384     int[] array = {(int) 0, (int) 1};
385     List<Integer> list = Ints.asList(array);
386     list.set(0, (int) 2);
387     assertTrue(Arrays.equals(new int[] {(int) 2, (int) 1}, array));
388     array[1] = (int) 3;
389     assertEquals(Arrays.asList((int) 2, (int) 3), list);
390   }
391 
392   public void testAsList_toArray_roundTrip() {
393     int[] array = { (int) 0, (int) 1, (int) 2 };
394     List<Integer> list = Ints.asList(array);
395     int[] newArray = Ints.toArray(list);
396 
397     // Make sure it returned a copy
398     list.set(0, (int) 4);
399     assertTrue(Arrays.equals(
400         new int[] { (int) 0, (int) 1, (int) 2 }, newArray));
401     newArray[1] = (int) 5;
402     assertEquals((int) 1, (int) list.get(1));
403   }
404 
405   // This test stems from a real bug found by andrewk
406   public void testAsList_subList_toArray_roundTrip() {
407     int[] array = { (int) 0, (int) 1, (int) 2, (int) 3 };
408     List<Integer> list = Ints.asList(array);
409     assertTrue(Arrays.equals(new int[] { (int) 1, (int) 2 },
410         Ints.toArray(list.subList(1, 3))));
411     assertTrue(Arrays.equals(new int[] {},
412         Ints.toArray(list.subList(2, 2))));
413   }
414 
415   public void testAsListEmpty() {
416     assertSame(Collections.emptyList(), Ints.asList(EMPTY));
417   }
418 
419   @GwtIncompatible("NullPointerTester")
420   public void testNulls() {
421     new NullPointerTester().testAllPublicStaticMethods(Ints.class);
422   }
423 
424   public void testStringConverter_convert() {
425     Converter<String, Integer> converter = Ints.stringConverter();
426     assertEquals((Integer) 1, converter.convert("1"));
427     assertEquals((Integer) 0, converter.convert("0"));
428     assertEquals((Integer) (-1), converter.convert("-1"));
429     assertEquals((Integer) 255, converter.convert("0xff"));
430     assertEquals((Integer) 255, converter.convert("0xFF"));
431     assertEquals((Integer) (-255), converter.convert("-0xFF"));
432     assertEquals((Integer) 255, converter.convert("#0000FF"));
433     assertEquals((Integer) 438, converter.convert("0666"));
434   }
435 
436   public void testStringConverter_convertError() {
437     try {
438       Ints.stringConverter().convert("notanumber");
439       fail();
440     } catch (NumberFormatException expected) {
441     }
442   }
443 
444   public void testStringConverter_nullConversions() {
445     assertNull(Ints.stringConverter().convert(null));
446     assertNull(Ints.stringConverter().reverse().convert(null));
447   }
448 
449   public void testStringConverter_reverse() {
450     Converter<String, Integer> converter = Ints.stringConverter();
451     assertEquals("1", converter.reverse().convert(1));
452     assertEquals("0", converter.reverse().convert(0));
453     assertEquals("-1", converter.reverse().convert(-1));
454     assertEquals("255", converter.reverse().convert(0xff));
455     assertEquals("255", converter.reverse().convert(0xFF));
456     assertEquals("-255", converter.reverse().convert(-0xFF));
457     assertEquals("438", converter.reverse().convert(0666));
458   }
459 
460   @GwtIncompatible("NullPointerTester")
461   public void testStringConverter_nullPointerTester() throws Exception {
462     NullPointerTester tester = new NullPointerTester();
463     tester.testAllPublicInstanceMethods(Ints.stringConverter());
464   }
465 
466   public void testTryParse() {
467     tryParseAndAssertEquals(0, "0");
468     tryParseAndAssertEquals(0, "-0");
469     tryParseAndAssertEquals(1, "1");
470     tryParseAndAssertEquals(-1, "-1");
471     tryParseAndAssertEquals(8900, "8900");
472     tryParseAndAssertEquals(-8900, "-8900");
473     tryParseAndAssertEquals(GREATEST, Integer.toString(GREATEST));
474     tryParseAndAssertEquals(LEAST, Integer.toString(LEAST));
475     assertNull(Ints.tryParse(""));
476     assertNull(Ints.tryParse("-"));
477     assertNull(Ints.tryParse("+1"));
478     assertNull(Ints.tryParse("9999999999999999"));
479     assertNull("Max integer + 1",
480         Ints.tryParse(Long.toString(((long) GREATEST) + 1)));
481     assertNull("Max integer * 10",
482         Ints.tryParse(Long.toString(((long) GREATEST) * 10)));
483     assertNull("Min integer - 1",
484         Ints.tryParse(Long.toString(((long) LEAST) - 1)));
485     assertNull("Min integer * 10",
486         Ints.tryParse(Long.toString(((long) LEAST) * 10)));
487     assertNull("Max long", Ints.tryParse(Long.toString(Long.MAX_VALUE)));
488     assertNull("Min long", Ints.tryParse(Long.toString(Long.MIN_VALUE)));
489     assertNull(Ints.tryParse("\u0662\u06f3"));
490   }
491 
492   /**
493    * Applies {@link Ints#tryParse(String)} to the given string and asserts that
494    * the result is as expected.
495    */
496   private static void tryParseAndAssertEquals(Integer expected, String value) {
497     assertEquals(expected, Ints.tryParse(value));
498   }
499 }